import type { Language, LanguageOption } from '../types'

export const languages: LanguageOption[] = [
  {
    name: 'ABAP',
    value: 'abap',
    grammar: () => import('./textmate/abap.tmLanguage.json'),
    scopeName: 'source.abap',
  },
  // Возможно несоответствие
  {
    name: 'ABC',
    value: 'abc',
    grammar: () => import('./textmate/abc.tmLanguage.json'),
    scopeName: 'text.abcnotation',
  },
  {
    name: 'ActionScript',
    value: 'actionscript',
    grammar: () => import('./textmate/actionscript-3.tmLanguage.json'),
    scopeName: 'source.actionscript.3',
  },
  {
    name: 'ADA',
    value: 'ada',
    grammar: () => import('./textmate/ada.tmLanguage.json'),
    scopeName: 'source.ada',
  },
  {
    name: 'Alda',
    value: 'alda',
    grammar: () => import('./textmate/alda.tmLanguage.json'),
    scopeName: 'source.alda',
  },
  {
    name: 'Apache Conf',
    value: 'apache_conf',
    grammar: () => import('./textmate/apache.tmLanguage.json'),
    scopeName: 'source.apacheconf',
  },
  {
    name: 'Apex',
    value: 'apex',
    grammar: () => import('./textmate/apex.tmLanguage.json'),
    scopeName: 'source.apex',
  },
  {
    name: 'Apple Script',
    value: 'applescript',
    grammar: () => import('./textmate/applescript.tmLanguage.json'),
    scopeName: 'source.applescript',
  },
  {
    name: 'AsciiDoc',
    value: 'asciidoc',
    grammar: () => import('./textmate/asciidoctor.tmLanguage.json'),
    scopeName: 'text.asciidoc',
  },
  {
    name: 'ASL',
    value: 'asl',
    grammar: () => import('./textmate/asl.tmLanguage.json'),
    scopeName: 'source.asl',
  },
  {
    name: 'ASP vb.NET (VBScript)',
    value: 'asp_vb_net',
    grammar: () => import('./textmate/asp-vb-net.tmlanguage.json'),
    scopeName: 'source.asp.vb.net',
  },
  {
    name: 'Assembly x86',
    value: 'assembly_x86',
    grammar: () => import('./textmate/asm.tmLanguage.json'),
    scopeName: 'source.asm',
  },
  {
    name: 'AutoHotkey / AutoIt',
    value: 'autohotkey',
    grammar: () => import('./textmate/autohotkey.tmLanguage.json'),
    scopeName: 'source.ahk',
  },
  {
    name: 'Bash',
    value: 'sh',
    grammar: () => import('./textmate/shell-unix-bash.tmLanguage.json'),
    scopeName: 'source.shell',
  },
  {
    name: 'BatchFile',
    value: 'batchfile',
    grammar: () => import('./textmate/batchfile.tmLanguage.json'),
    scopeName: 'source.batchfile',
  },
  {
    name: 'Bicep',
    value: 'bicep',
    grammar: () => import('./textmate/bicep.tmLanguage.json'),
    scopeName: 'source.bicep',
  },
  {
    name: 'C and C++',
    value: 'c_cpp',
    grammar: () => import('./textmate/cpp.tmLanguage.json'),
    scopeName: 'source.cpp',
  },
  {
    name: 'C#',
    value: 'csharp',
    grammar: () => import('./textmate/csharp.tmLanguage.json'),
    scopeName: 'source.cs',
  },
  {
    name: 'Cirru',
    value: 'cirru',
    grammar: () => import('./textmate/cirru.tmLanguage.json'),
    scopeName: 'source.cirru',
  },
  {
    name: 'Clojure',
    value: 'clojure',
    grammar: () => import('./textmate/clojure.tmLanguage.json'),
    scopeName: 'source.clojure',
  },
  {
    name: 'Cobol',
    value: 'cobol',
    grammar: () => import('./textmate/cobol.tmLanguage.json'),
    scopeName: 'source.cobol',
  },
  {
    name: 'CoffeeScript',
    value: 'coffee',
    grammar: () => import('./textmate/coffee.tmLanguage.json'),
    scopeName: 'source.coffee',
  },
  {
    name: 'ColdFusion',
    value: 'coldfusion',
    grammar: () => import('./textmate/coldfusion.tmLanguage.json'),
    scopeName: 'text.cfml.basic',
  },
  {
    name: 'Crystal',
    value: 'crystal',
    grammar: () => import('./textmate/crystal.tmLanguage.json'),
    scopeName: 'source.crystal',
  },
  {
    name: 'Csound',
    value: 'csound_orchestra',
    grammar: () => import('./textmate/csound.tmLanguage.json'),
    scopeName: 'source.csound',
  },
  {
    name: 'Csound Document',
    value: 'csound_document',
    grammar: () => import('./textmate/csound-document.tmLanguage.json'),
    scopeName: 'source.csound-document',
  },
  {
    name: 'Csound Score',
    value: 'csound_score',
    grammar: () => import('./textmate/csound-score.tmLanguage.json'),
    scopeName: 'source.csound-score',
  },
  {
    name: 'CSS',
    value: 'css',
    grammar: () => import('./textmate/css.tmLanguage.json'),
    scopeName: 'source.css',
  },
  {
    name: 'Curly',
    value: 'curly',
    grammar: () => import('./textmate/curly.tmLanguage.json'),
    scopeName: 'text.html.curly',
  },
  {
    name: 'D',
    value: 'd',
    grammar: () => import('./textmate/d.tmLanguage.json'),
    scopeName: 'source.d',
  },
  {
    name: 'Dart',
    value: 'dart',
    grammar: () => import('./textmate/dart.tmLanguage.json'),
    scopeName: 'source.dart',
  },
  {
    name: 'Diff',
    value: 'diff',
    grammar: () => import('./textmate/diff.tmLanguage.json'),
    scopeName: 'source.diff',
  },
  {
    name: 'Django',
    value: 'django',
    grammar: () => import('./textmate/django.tmLanguage.json'),
    scopeName: 'source.python.django',
  },
  {
    name: 'Dockerfile',
    value: 'dockerfile',
    grammar: () => import('./textmate/docker.tmLanguage.json'),
    scopeName: 'source.dockerfile',
  },
  {
    name: 'Dot',
    value: 'dot',
    grammar: () => import('./textmate/dot.tmLanguage.json'),
    scopeName: 'source.dot',
  },
  {
    name: 'Drools',
    value: 'drools',
    grammar: () => import('./textmate/drools.tmLanguage.json'),
    scopeName: 'source.drools',
  },
  {
    name: 'Edifact',
    value: 'edifact',
    grammar: () => import('./textmate/edifact.tmLanguage.json'),
    scopeName: 'text.plain.edifact',
  },
  {
    name: 'Eiffel',
    value: 'eiffel',
    grammar: () => import('./textmate/eiffel.tmLanguage.json'),
    scopeName: 'source.eiffel',
  },
  {
    name: 'EJS',
    value: 'ejs',
    grammar: () => import('./textmate/ejs.tmLanguage.json'),
    scopeName: 'text.html.js',
  },
  {
    name: 'Elixir',
    value: 'elixir',
    grammar: () => import('./textmate/elixir.tmLanguage.json'),
    scopeName: 'source.elixir',
  },
  {
    name: 'Elm',
    value: 'elm',
    grammar: () => import('./textmate/elm.tmLanguage.json'),
    scopeName: 'source.elm',
  },
  {
    name: 'Erlang',
    value: 'erlang',
    grammar: () => import('./textmate/erlang.tmLanguage.json'),
    scopeName: 'source.erlang',
  },
  {
    name: 'Forth',
    value: 'forth',
    grammar: () => import('./textmate/forth.tmLanguage.json'),
    scopeName: 'source.forth',
  },
  {
    name: 'Fortran',
    value: 'fortran',
    grammar: () => import('./textmate/fortran.tmLanguage.json'),
    scopeName: 'source.fortran',
  },
  {
    name: 'F#',
    value: 'fsharp',
    grammar: () => import('./textmate/fsharp.tmLanguage.json'),
    scopeName: 'source.fsharp',
  },
  {
    name: 'Gcode',
    value: 'gcode',
    grammar: () => import('./textmate/gcode.tmLanguage.json'),
    scopeName: 'source.gcode',
  },
  {
    name: 'Gherkin',
    value: 'gherkin',
    grammar: () => import('./textmate/gherkin.tmLanguage.json'),
    scopeName: 'text.gherkin.feature',
  },
  {
    name: 'Gitignore',
    value: 'gitignore',
    grammar: () => import('./textmate/gitignore.tmLanguage.json'),
    scopeName: 'source.gitignore',
  },
  {
    name: 'Glsl',
    value: 'glsl',
    grammar: () => import('./textmate/glsl.tmLanguage.json'),
    scopeName: 'source.glsl',
  },
  {
    name: 'Go',
    value: 'golang',
    grammar: () => import('./textmate/go.tmLanguage.json'),
    scopeName: 'source.go',
  },
  {
    name: 'GraphQL',
    value: 'graphqlschema',
    grammar: () => import('./textmate/graphql.tmLanguage.json'),
    scopeName: 'source.graphql',
  },
  {
    name: 'Groovy',
    value: 'groovy',
    grammar: () => import('./textmate/groovy.tmLanguage.json'),
    scopeName: 'source.groovy',
  },
  {
    name: 'HAML',
    value: 'haml',
    grammar: () => import('./textmate/haml.tmLanguage.json'),
    scopeName: 'text.haml',
  },
  {
    name: 'Handlebars',
    value: 'handlebars',
    grammar: () => import('./textmate/handlebars.tmLanguage.json'),
    scopeName: 'text.html.handlebars',
  },
  // Возможно несоответствие
  {
    name: 'Haskell Cabal',
    value: 'haskell_cabal',
    grammar: () => import('./textmate/haskell-cabal.tmLanguage.json'),
    scopeName: 'source.cabal',
  },
  {
    name: 'Haskell',
    value: 'haskell',
    grammar: () => import('./textmate/haskell.tmLanguage.json'),
    scopeName: 'source.haskell',
  },
  {
    name: 'haXe',
    value: 'haxe',
    grammar: () => import('./textmate/haxe.tmLanguage.json'),
    scopeName: 'source.hx',
  },
  {
    name: 'Hjson',
    value: 'hjson',
    grammar: () => import('./textmate/hjson.tmLanguage.json'),
    scopeName: 'source.hjson',
  },
  {
    name: 'HTML (Elixir)',
    value: 'html_elixir',
    grammar: () => import('./textmate/html-elixir.tmLanguage.json'),
    scopeName: 'text.html.elixir',
  },
  {
    name: 'HTML (Ruby)',
    value: 'html_ruby',
    grammar: () => import('./textmate/html-ruby.tmLanguage.json'),
    scopeName: 'text.html.erb',
  },
  {
    name: 'HTML',
    value: 'html',
    grammar: () => import('./textmate/html.tmLanguage.json'),
    scopeName: 'text.html.basic',
  },
  {
    name: 'INI',
    value: 'ini',
    grammar: () => import('./textmate/ini.tmLanguage.json'),
    scopeName: 'source.ini',
  },
  {
    name: 'Io',
    value: 'io',
    grammar: () => import('./textmate/io.tmLanguage.json'),
    scopeName: 'source.io',
  },
  {
    name: 'Java',
    value: 'java',
    grammar: () => import('./textmate/java.tmLanguage.json'),
    scopeName: 'source.java',
  },
  {
    name: 'JavaScript',
    value: 'javascript',
    grammar: () => import('./textmate/javascript.tmLanguage.json'),
    scopeName: 'source.js',
  },
  {
    name: 'JSON',
    value: 'json',
    grammar: () => import('./textmate/json.tmLanguage.json'),
    scopeName: 'source.json',
  },
  {
    name: 'JSON5',
    value: 'json5',
    grammar: () => import('./textmate/json5.tmLanguage.json'),
    scopeName: 'source.json5',
  },
  {
    name: 'JSONiq',
    value: 'jsoniq',
    grammar: () => import('./textmate/jsoniq.tmLanguage.json'),
    scopeName: 'source.jsoniq',
  },
  {
    name: 'JSP',
    value: 'jsp',
    grammar: () => import('./textmate/jsp.tmLanguage.json'),
    scopeName: 'text.html.jsp',
  },
  // TODO: сделать общими стилизованые (.jsx, tsx) грамматики
  {
    name: 'JSX',
    value: 'jsx',
    grammar: () => import('./textmate/jsx.tmLanguage.json'),
    scopeName: 'source.jsx',
  },
  {
    name: 'Julia',
    value: 'julia',
    grammar: () => import('./textmate/julia.tmLanguage.json'),
    scopeName: 'source.julia',
  },
  {
    name: 'Kotlin',
    value: 'kotlin',
    grammar: () => import('./textmate/kotlin.tmLanguage.json'),
    scopeName: 'source.kotlin',
  },
  {
    name: 'Kusto (KQL)',
    value: 'kusto',
    grammar: () => import('./textmate/kusto.tmLanguage.json'),
    scopeName: 'source.kusto',
  },
  {
    name: 'LaTeX',
    value: 'latex',
    grammar: () => import('./textmate/latex.tmLanguage.json'),
    scopeName: 'text.tex.latex',
  },
  {
    name: 'Latte',
    value: 'latte',
    grammar: () => import('./textmate/latte.tmLanguage.json'),
    scopeName: 'source.latte',
  },
  {
    name: 'LESS',
    value: 'less',
    grammar: () => import('./textmate/less.tmLanguage.json'),
    scopeName: 'source.css.less',
  },
  {
    name: 'Liquid',
    value: 'liquid',
    grammar: () => import('./textmate/liquid.tmLanguage.json'),
    scopeName: 'source.liquid',
  },
  {
    name: 'Lisp',
    value: 'lisp',
    grammar: () => import('./textmate/lisp.tmLanguage.json'),
    scopeName: 'source.lisp',
  },
  {
    name: 'LiveScript',
    value: 'livescript',
    grammar: () => import('./textmate/livescript.tmLanguage.json'),
    scopeName: 'source.livescript',
  },
  {
    name: 'LSL',
    value: 'lsl',
    grammar: () => import('./textmate/lsl.tmLanguage.json'),
    scopeName: 'source.lsl',
  },
  {
    name: 'Lua',
    value: 'lua',
    grammar: () => import('./textmate/lua.tmLanguage.json'),
    scopeName: 'source.lua',
  },
  {
    name: 'Makefile',
    value: 'makefile',
    grammar: () => import('./textmate/make.tmLanguage.json'),
    scopeName: 'source.makefile',
  },
  {
    name: 'Markdown',
    value: 'markdown',
    grammar: () => import('./textmate/markdown.tmLanguage.json'),
    scopeName: 'text.html.markdown',
  },
  {
    name: 'Mask',
    value: 'mask',
    grammar: () => import('./textmate/mask.tmLanguage.json'),
    scopeName: 'source.mask',
  },
  {
    name: 'MATLAB',
    value: 'matlab',
    grammar: () => import('./textmate/matlab.tmLanguage.json'),
    scopeName: 'source.matlab',
  },
  {
    name: 'MediaWiki',
    value: 'mediawiki',
    grammar: () => import('./textmate/mediawiki.tmLanguage.json'),
    scopeName: 'text.html.mediawiki',
  },
  {
    name: 'MEL',
    value: 'mel',
    grammar: () => import('./textmate/mel.tmLanguage.json'),
    scopeName: 'source.mel',
  },
  {
    name: 'Mikrotik',
    value: 'mikrotik',
    grammar: () => import('./textmate/mikrotik.tmLanguage.json'),
    scopeName: 'source.mikrotik-script',
  },
  {
    name: 'MIPS',
    value: 'mips',
    grammar: () => import('./textmate/mips.tmLanguage.json'),
    scopeName: 'source.mips',
  },
  {
    name: 'MySQL',
    value: 'mysql',
    grammar: () => import('./textmate/mysql.tmLanguage.json'),
    scopeName: 'source.sql.mysql',
  },
  {
    name: 'Nginx',
    value: 'nginx',
    grammar: () => import('./textmate/nginx.tmLanguage.json'),
    scopeName: 'source.nginx',
  },
  {
    name: 'Nim',
    value: 'nim',
    grammar: () => import('./textmate/nim.tmLanguage.json'),
    scopeName: 'source.nim',
  },
  {
    name: 'Nix',
    value: 'nix',
    grammar: () => import('./textmate/nix.tmLanguage.json'),
    scopeName: 'source.nix',
  },
  {
    name: 'NSIS',
    value: 'nsis',
    grammar: () => import('./textmate/nsis.tmLanguage.json'),
    scopeName: 'source.nsis',
  },
  {
    name: 'Nunjucks',
    value: 'nunjucks',
    grammar: () => import('./textmate/nunjucks.tmLanguage.json'),
    scopeName: 'text.html.nunjucks',
  },
  {
    name: 'Objective-C',
    value: 'objectivec',
    grammar: () => import('./textmate/objective-c.tmLanguage.json'),
    scopeName: 'source.objc',
  },
  {
    name: 'OCaml',
    value: 'ocaml',
    grammar: () => import('./textmate/ocaml.tmLanguage.json'),
    scopeName: 'source.ocaml',
  },
  {
    name: 'OpenGL',
    value: 'glsl',
    grammar: () => import('./textmate/glsl.tmLanguage.json'),
    scopeName: 'source.glsl',
  },
  {
    name: 'Pascal',
    value: 'pascal',
    grammar: () => import('./textmate/pascal.tmLanguage.json'),
    scopeName: 'source.pascal',
  },
  {
    name: 'Perl',
    value: 'perl',
    grammar: () => import('./textmate/perl.tmLanguage.json'),
    scopeName: 'source.perl',
  },
  {
    name: 'pgSQL',
    value: 'pgsql',
    grammar: () => import('./textmate/pgsql.tmLanguage.json'),
    scopeName: 'source.pgsql',
  },
  {
    name: 'PHP (Blade Template)',
    value: 'php_laravel_blade',
    grammar: () => import('./textmate/php-blade.tmLanguage.json'),
    scopeName: 'text.html.php.blade',
  },
  {
    name: 'PHP',
    value: 'php',
    grammar: () => import('./textmate/php.tmLanguage.json'),
    scopeName: 'source.php',
  },
  {
    name: 'Pig',
    value: 'pig',
    grammar: () => import('./textmate/pig.tmLanguage.json'),
    scopeName: 'source.pig',
  },
  {
    name: 'Plain Text',
    value: 'plain_text',
    grammar: () => import('./textmate/plain-text.tmLanguage.json'),
    scopeName: 'text.plain',
  },
  {
    name: 'Powershell',
    value: 'powershell',
    grammar: () => import('./textmate/powershell.tmLanguage.json'),
    scopeName: 'source.powershell',
  },
  {
    name: 'Praat',
    value: 'praat',
    grammar: () => import('./textmate/praat.tmLanguage.json'),
    scopeName: 'source.praat',
  },
  {
    name: 'Prisma',
    value: 'prisma',
    grammar: () => import('./textmate/prisma.tmLanguage.json'),
    scopeName: 'source.prisma',
  },
  {
    name: 'Prolog',
    value: 'prolog',
    grammar: () => import('./textmate/prolog.tmLanguage.json'),
    scopeName: 'source.prolog',
  },
  {
    name: 'Properties',
    value: 'properties',
    grammar: () => import('./textmate/properties.tmLanguage.json'),
    scopeName: 'source.tm-properties',
  },
  {
    name: 'Protobuf',
    value: 'protobuf',
    grammar: () => import('./textmate/protobuf.tmLanguage.json'),
    scopeName: 'source.proto',
  },
  {
    name: 'Pug',
    value: 'pug',
    grammar: () => import('./textmate/pug.tmLanguage.json'),
    scopeName: 'text.pug',
  },
  {
    name: 'Puppet',
    value: 'puppet',
    grammar: () => import('./textmate/puppet.tmLanguage.json'),
    scopeName: 'source.puppet',
  },
  {
    name: 'Python',
    value: 'python',
    grammar: () => import('./textmate/python.tmLanguage.json'),
    scopeName: 'source.python',
  },
  {
    name: 'QML',
    value: 'qml',
    grammar: () => import('./textmate/qml.tmLanguage.json'),
    scopeName: 'source.qml',
  },
  {
    name: 'R',
    value: 'r',
    grammar: () => import('./textmate/r.tmLanguage.json'),
    scopeName: 'source.r',
  },
  {
    name: 'Raku',
    value: 'raku',
    grammar: () => import('./textmate/raku.tmLanguage.json'),
    scopeName: 'source.perl.6',
  },
  {
    name: 'Razor',
    value: 'razor',
    grammar: () => import('./textmate/razor.tmLanguage.json'),
    scopeName: 'text.aspnetcorerazor',
  },
  {
    name: 'Red',
    value: 'red',
    grammar: () => import('./textmate/red.tmLanguage.json'),
    scopeName: 'source.red',
  },
  {
    name: 'RegExp',
    value: 'regexp',
    grammar: () => import('./textmate/regexp.tmLanguage.json'),
    scopeName: 'source.regexp',
  },
  {
    name: 'RST',
    value: 'rst',
    grammar: () => import('./textmate/rst.tmLanguage.json'),
    scopeName: 'source.rst',
  },
  {
    name: 'Ruby',
    value: 'ruby',
    grammar: () => import('./textmate/ruby.tmLanguage.json'),
    scopeName: 'source.ruby',
  },
  {
    name: 'Rust',
    value: 'rust',
    grammar: () => import('./textmate/rust.tmLanguage.json'),
    scopeName: 'source.rust',
  },
  {
    name: 'SAS',
    value: 'sas',
    grammar: () => import('./textmate/sas.tmLanguage.json'),
    scopeName: 'source.sas',
  },
  {
    name: 'SASS',
    value: 'sass',
    grammar: () => import('./textmate/sass.tmLanguage.json'),
    scopeName: 'source.sass',
  },
  {
    name: 'SCAD',
    value: 'scad',
    grammar: () => import('./textmate/scad.tmLanguage.json'),
    scopeName: 'source.scad',
  },
  {
    name: 'Scala',
    value: 'scala',
    grammar: () => import('./textmate/scala.tmLanguage.json'),
    scopeName: 'source.scala',
  },
  {
    name: 'Scheme',
    value: 'scheme',
    grammar: () => import('./textmate/scheme.tmLanguage.json'),
    scopeName: 'source.scheme',
  },
  {
    name: 'sCrypt',
    value: 'scrypt',
    grammar: () => import('./textmate/scrypt.tmLanguage.json'),
    scopeName: 'source.scrypt',
  },
  {
    name: 'SCSS',
    value: 'scss',
    grammar: () => import('./textmate/scss.tmLanguage.json'),
    scopeName: 'source.css.scss',
  },
  {
    name: 'SJS',
    value: 'sjs',
    grammar: () => import('./textmate/sjs.tmLanguage.json'),
    scopeName: 'source.sjs',
  },
  {
    name: 'Slim',
    value: 'slim',
    grammar: () => import('./textmate/slim.tmLanguage.json'),
    scopeName: 'text.slim',
  },
  {
    name: 'Smalltalk',
    value: 'smalltalk',
    grammar: () => import('./textmate/smalltalk.tmLanguage.json'),
    scopeName: 'source.smalltalk',
  },
  {
    name: 'Smarty',
    value: 'smarty',
    grammar: () => import('./textmate/smarty.tmLanguage.json'),
    scopeName: 'source.smarty',
  },
  {
    name: 'Smithy',
    value: 'smithy',
    grammar: () => import('./textmate/smithy.tmLanguage.json'),
    scopeName: 'source.smithy',
  },
  {
    name: 'Solidity',
    value: 'solidity',
    grammar: () => import('./textmate/solidity.tmLanguage.json'),
    scopeName: 'source.solidity',
  },
  {
    name: 'Soy Template',
    value: 'soy_template',
    grammar: () => import('./textmate/soytemplate.tmLanguage.json'),
    scopeName: 'source.soy',
  },
  {
    name: 'SQL',
    value: 'sql',
    grammar: () => import('./textmate/sql.tmLanguage.json'),
    scopeName: 'source.sql',
  },
  {
    name: 'SQLServer',
    value: 'sqlserver',
    grammar: () => import('./textmate/sql.tmLanguage.json'),
    scopeName: 'source.sqlserver',
  },
  {
    name: 'Stylus',
    value: 'stylus',
    grammar: () => import('./textmate/less.tmLanguage.json'),
    scopeName: 'source.stylus',
  },
  {
    name: 'SVG',
    value: 'svg',
    grammar: () => import('./textmate/svg.tmLanguage.json'),
    scopeName: 'text.xml.svg',
  },
  {
    name: 'Swift',
    value: 'swift',
    grammar: () => import('./textmate/swift.tmLanguage.json'),
    scopeName: 'source.swift',
  },
  {
    name: 'Tcl',
    value: 'tcl',
    grammar: () => import('./textmate/tcl.tmLanguage.json'),
    scopeName: 'source.tcl',
  },
  {
    name: 'Terraform',
    value: 'terraform',
    grammar: () => import('./textmate/terraform.tmLanguage.json'),
    scopeName: 'source.terraform',
  },
  {
    name: 'Tex',
    value: 'tex',
    grammar: () => import('./textmate/tex.tmLanguage.json'),
    scopeName: 'text.tex',
  },
  {
    name: 'Textile',
    value: 'textile',
    grammar: () => import('./textmate/textile.tmLanguage.json'),
    scopeName: 'text.html.textile',
  },
  {
    name: 'TOML',
    value: 'toml',
    grammar: () => import('./textmate/toml.tmLanguage.json'),
    scopeName: 'source.toml',
  },
  {
    name: 'TSX',
    value: 'tsx',
    grammar: () => import('./textmate/tsx.tmLanguage.json'),
    scopeName: 'source.tsx',
  },
  {
    name: 'Twig',
    value: 'twig',
    grammar: () => import('./textmate/twig.tmLanguage.json'),
    scopeName: 'text.html.twig',
  },
  {
    name: 'TypeScript',
    value: 'typescript',
    grammar: () => import('./textmate/typescript.tmLanguage.json'),
    scopeName: 'source.ts',
  },
  {
    name: 'Vala',
    value: 'vala',
    grammar: () => import('./textmate/vala.tmLanguage.json'),
    scopeName: 'source.vala',
  },
  {
    name: 'Velocity',
    value: 'velocity',
    grammar: () => import('./textmate/velocity.tmLanguage.json'),
    scopeName: 'text.velocity',
  },
  {
    name: 'Verilog',
    value: 'verilog',
    grammar: () => import('./textmate/systemverilog.tmLanguage.json'),
    scopeName: 'source.systemverilog',
  },
  {
    name: 'VHDL',
    value: 'vhdl',
    grammar: () => import('./textmate/vhdl.tmLanguage.json'),
    scopeName: 'source.vhdl',
  },
  {
    name: 'Visualforce',
    value: 'visualforce',
    grammar: () => import('./textmate/visualforce.tmLanguage.json'),
    scopeName: 'text.visualforce.markup',
  },
  {
    name: 'Vue',
    value: 'vue',
    grammar: () => import('./textmate/vue.tmLanguage.json'),
    scopeName: 'text.html.vue',
  },
  {
    name: 'Wollok',
    value: 'wollok',
    grammar: () => import('./textmate/wollok.tmLanguage.json'),
    scopeName: 'source.wollok',
  },
  {
    name: 'XML',
    value: 'xml',
    grammar: () => import('./textmate/xml.tmLanguage.json'),
    scopeName: 'text.xml',
  },
  {
    name: 'XSL',
    value: 'xsl',
    grammar: () => import('./textmate/xsl.tmLanguage.json'),
    scopeName: 'text.xml.xsl',
  },
  {
    name: 'XQuery',
    value: 'xquery',
    grammar: () => import('./textmate/xquery.tmLanguage.json'),
    scopeName: 'source.xquery',
  },
  {
    name: 'YAML',
    value: 'yaml',
    grammar: () => import('./textmate/yaml.tmLanguage.json'),
    scopeName: 'source.yaml',
  },
  {
    name: 'Zeek',
    value: 'zeek',
    grammar: () => import('./textmate/zeek.tmLanguage.json'),
    scopeName: 'source.zeek',
  },
]

// Маппинг с версии v1
export const oldLanguageMap: Record<any, Language> = {
  'azcli': 'plain_text',
  'bat': 'sh',
  'cameligo': 'plain_text',
  'coffeescript': 'coffee',
  'c': 'c_cpp',
  'csp': 'plain_text',
  'go': 'golang',
  'graphql': 'graphqlschema',
  'msdax': 'plain_text',
  'objective-c': 'objectivec',
  'pascaligo': 'plain_text',
  'postiats': 'plain_text',
  'powerquery': 'plain_text',
  'pug': 'jade',
  'redis': 'plain_text',
  'sb': 'plain_text',
  'shell': 'sh',
  'sol': 'plain_text',
  'aes': 'plain_text',
  'st': 'plain_text',
  'vb': 'vbscript',
}
